home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / lib / python2.6 / distutils / util.py < prev    next >
Encoding:
Python Source  |  2010-12-26  |  21.5 KB  |  577 lines
  1. """distutils.util
  2.  
  3. Miscellaneous utility functions -- anything that doesn't fit into
  4. one of the other *util.py modules.
  5. """
  6.  
  7. __revision__ = "$Id: util.py 83588 2010-08-02 21:35:06Z ezio.melotti $"
  8.  
  9. import sys, os, string, re
  10. from distutils.errors import DistutilsPlatformError
  11. from distutils.dep_util import newer
  12. from distutils.spawn import spawn
  13. from distutils import log
  14. from distutils.errors import DistutilsByteCompileError
  15.  
  16. def get_platform ():
  17.     """Return a string that identifies the current platform.  This is used
  18.     mainly to distinguish platform-specific build directories and
  19.     platform-specific built distributions.  Typically includes the OS name
  20.     and version and the architecture (as supplied by 'os.uname()'),
  21.     although the exact information included depends on the OS; eg. for IRIX
  22.     the architecture isn't particularly important (IRIX only runs on SGI
  23.     hardware), but for Linux the kernel version isn't particularly
  24.     important.
  25.  
  26.     Examples of returned values:
  27.        linux-i586
  28.        linux-alpha (?)
  29.        solaris-2.6-sun4u
  30.        irix-5.3
  31.        irix64-6.2
  32.  
  33.     Windows will return one of:
  34.        win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
  35.        win-ia64 (64bit Windows on Itanium)
  36.        win32 (all others - specifically, sys.platform is returned)
  37.  
  38.     For other non-POSIX platforms, currently just returns 'sys.platform'.
  39.     """
  40.     if os.name == 'nt':
  41.         # sniff sys.version for architecture.
  42.         prefix = " bit ("
  43.         i = string.find(sys.version, prefix)
  44.         if i == -1:
  45.             return sys.platform
  46.         j = string.find(sys.version, ")", i)
  47.         look = sys.version[i+len(prefix):j].lower()
  48.         if look=='amd64':
  49.             return 'win-amd64'
  50.         if look=='itanium':
  51.             return 'win-ia64'
  52.         return sys.platform
  53.  
  54.     if os.name != "posix" or not hasattr(os, 'uname'):
  55.         # XXX what about the architecture? NT is Intel or Alpha,
  56.         # Mac OS is M68k or PPC, etc.
  57.         return sys.platform
  58.  
  59.     # Try to distinguish various flavours of Unix
  60.  
  61.     (osname, host, release, version, machine) = os.uname()
  62.  
  63.     # Convert the OS name to lowercase, remove '/' characters
  64.     # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
  65.     osname = string.lower(osname)
  66.     osname = string.replace(osname, '/', '')
  67.     machine = string.replace(machine, ' ', '_')
  68.     machine = string.replace(machine, '/', '-')
  69.  
  70.     if osname[:5] == "linux":
  71.         # At least on Linux/Intel, 'machine' is the processor --
  72.         # i386, etc.
  73.         # XXX what about Alpha, SPARC, etc?
  74.         return  "%s-%s" % (osname, machine)
  75.     elif osname[:5] == "sunos":
  76.         if release[0] >= "5":           # SunOS 5 == Solaris 2
  77.             osname = "solaris"
  78.             release = "%d.%s" % (int(release[0]) - 3, release[2:])
  79.         # fall through to standard osname-release-machine representation
  80.     elif osname[:4] == "irix":              # could be "irix64"!
  81.         return "%s-%s" % (osname, release)
  82.     elif osname[:3] == "aix":
  83.         return "%s-%s.%s" % (osname, version, release)
  84.     elif osname[:6] == "cygwin":
  85.         osname = "cygwin"
  86.         rel_re = re.compile (r'[\d.]+')
  87.         m = rel_re.match(release)
  88.         if m:
  89.             release = m.group()
  90.     elif osname[:6] == "darwin":
  91.         #
  92.         # For our purposes, we'll assume that the system version from
  93.         # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
  94.         # to. This makes the compatibility story a bit more sane because the
  95.         # machine is going to compile and link as if it were
  96.         # MACOSX_DEPLOYMENT_TARGET.
  97.         from distutils.sysconfig import get_config_vars
  98.         cfgvars = get_config_vars()
  99.  
  100.         macver = os.environ.get('MACOSX_DEPLOYMENT_TARGET')
  101.         if not macver:
  102.             macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET')
  103.  
  104.         if 1:
  105.             # Always calculate the release of the running machine,
  106.             # needed to determine if we can build fat binaries or not.
  107.  
  108.             macrelease = macver
  109.             # Get the system version. Reading this plist is a documented
  110.             # way to get the system version (see the documentation for
  111.             # the Gestalt Manager)
  112.             try:
  113.                 f = open('/System/Library/CoreServices/SystemVersion.plist')
  114.             except IOError:
  115.                 # We're on a plain darwin box, fall back to the default
  116.                 # behaviour.
  117.                 pass
  118.             else:
  119.                 m = re.search(
  120.                         r'<key>ProductUserVisibleVersion</key>\s*' +
  121.                         r'<string>(.*?)</string>', f.read())
  122.                 f.close()
  123.                 if m is not None:
  124.                     macrelease = '.'.join(m.group(1).split('.')[:2])
  125.                 # else: fall back to the default behaviour
  126.  
  127.         if not macver:
  128.             macver = macrelease
  129.  
  130.         if macver:
  131.             from distutils.sysconfig import get_config_vars
  132.             release = macver
  133.             osname = "macosx"
  134.  
  135.             if (macrelease + '.') >= '10.4.' and \
  136.                     '-arch' in get_config_vars().get('CFLAGS', '').strip():
  137.                 # The universal build will build fat binaries, but not on
  138.                 # systems before 10.4
  139.                 #
  140.                 # Try to detect 4-way universal builds, those have machine-type
  141.                 # 'universal' instead of 'fat'.
  142.  
  143.                 machine = 'fat'
  144.                 cflags = get_config_vars().get('CFLAGS')
  145.  
  146.                 archs = re.findall('-arch\s+(\S+)', cflags)
  147.                 archs = tuple(sorted(set(archs)))
  148.  
  149.                 if len(archs) == 1:
  150.                     machine = archs[0]
  151.                 elif archs == ('i386', 'ppc'):
  152.                     machine = 'fat'
  153.                 elif archs == ('i386', 'x86_64'):
  154.                     machine = 'intel'
  155.                 elif archs == ('i386', 'ppc', 'x86_64'):
  156.                     machine = 'fat3'
  157.                 elif archs == ('ppc64', 'x86_64'):
  158.                     machine = 'fat64'
  159.                 elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'):
  160.                     machine = 'universal'
  161.                 else:
  162.                     raise ValueError(
  163.                        "Don't know machine value for archs=%r"%(archs,))
  164.  
  165.             elif machine == 'i386':
  166.                 # On OSX the machine type returned by uname is always the
  167.                 # 32-bit variant, even if the executable architecture is
  168.                 # the 64-bit variant
  169.                 if sys.maxint >= 2**32:
  170.                     machine = 'x86_64'
  171.  
  172.             elif machine in ('PowerPC', 'Power_Macintosh'):
  173.                 # Pick a sane name for the PPC architecture.
  174.                 machine = 'ppc'
  175.  
  176.                 # See 'i386' case
  177.                 if sys.maxint >= 2**32:
  178.                     machine = 'ppc64'
  179.  
  180.     return "%s-%s-%s" % (osname, release, machine)
  181.  
  182. # get_platform ()
  183.  
  184.  
  185. def convert_path (pathname):
  186.     """Return 'pathname' as a name that will work on the native filesystem,
  187.     i.e. split it on '/' and put it back together again using the current
  188.     directory separator.  Needed because filenames in the setup script are
  189.     always supplied in Unix style, and have to be converted to the local
  190.     convention before we can actually use them in the filesystem.  Raises
  191.     ValueError on non-Unix-ish systems if 'pathname' either starts or
  192.     ends with a slash.
  193.     """
  194.     if os.sep == '/':
  195.         return pathname
  196.     if not pathname:
  197.         return pathname
  198.     if pathname[0] == '/':
  199.         raise ValueError, "path '%s' cannot be absolute" % pathname
  200.     if pathname[-1] == '/':
  201.         raise ValueError, "path '%s' cannot end with '/'" % pathname
  202.  
  203.     paths = string.split(pathname, '/')
  204.     while '.' in paths:
  205.         paths.remove('.')
  206.     if not paths:
  207.         return os.curdir
  208.     return os.path.join(*paths)
  209.  
  210. # convert_path ()
  211.  
  212.  
  213. def change_root (new_root, pathname):
  214.     """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
  215.     relative, this is equivalent to "os.path.join(new_root,pathname)".
  216.     Otherwise, it requires making 'pathname' relative and then joining the
  217.     two, which is tricky on DOS/Windows and Mac OS.
  218.     """
  219.     if os.name == 'posix':
  220.         if not os.path.isabs(pathname):
  221.             return os.path.join(new_root, pathname)
  222.         else:
  223.             return os.path.join(new_root, pathname[1:])
  224.  
  225.     elif os.name == 'nt':
  226.         (drive, path) = os.path.splitdrive(pathname)
  227.         if path[0] == '\\':
  228.             path = path[1:]
  229.         return os.path.join(new_root, path)
  230.  
  231.     elif os.name == 'os2':
  232.         (drive, path) = os.path.splitdrive(pathname)
  233.         if path[0] == os.sep:
  234.             path = path[1:]
  235.         return os.path.join(new_root, path)
  236.  
  237.     elif os.name == 'mac':
  238.         if not os.path.isabs(pathname):
  239.             return os.path.join(new_root, pathname)
  240.         else:
  241.             # Chop off volume name from start of path
  242.             elements = string.split(pathname, ":", 1)
  243.             pathname = ":" + elements[1]
  244.             return os.path.join(new_root, pathname)
  245.  
  246.     else:
  247.         raise DistutilsPlatformError, \
  248.               "nothing known about platform '%s'" % os.name
  249.  
  250.  
  251. _environ_checked = 0
  252. def check_environ ():
  253.     """Ensure that 'os.environ' has all the environment variables we
  254.     guarantee that users can use in config files, command-line options,
  255.     etc.  Currently this includes:
  256.       HOME - user's home directory (Unix only)
  257.       PLAT - description of the current platform, including hardware
  258.              and OS (see 'get_platform()')
  259.     """
  260.     global _environ_checked
  261.     if _environ_checked:
  262.         return
  263.  
  264.     if os.name == 'posix' and 'HOME' not in os.environ:
  265.         import pwd
  266.         os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
  267.  
  268.     if 'PLAT' not in os.environ:
  269.         os.environ['PLAT'] = get_platform()
  270.  
  271.     _environ_checked = 1
  272.  
  273.  
  274. def subst_vars (s, local_vars):
  275.     """Perform shell/Perl-style variable substitution on 'string'.  Every
  276.     occurrence of '$' followed by a name is considered a variable, and
  277.     variable is substituted by the value found in the 'local_vars'
  278.     dictionary, or in 'os.environ' if it's not in 'local_vars'.
  279.     'os.environ' is first checked/augmented to guarantee that it contains
  280.     certain values: see 'check_environ()'.  Raise ValueError for any
  281.     variables not found in either 'local_vars' or 'os.environ'.
  282.     """
  283.     check_environ()
  284.     def _subst (match, local_vars=local_vars):
  285.         var_name = match.group(1)
  286.         if var_name in local_vars:
  287.             return str(local_vars[var_name])
  288.         else:
  289.             return os.environ[var_name]
  290.  
  291.     try:
  292.         return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
  293.     except KeyError, var:
  294.         raise ValueError, "invalid variable '$%s'" % var
  295.  
  296. # subst_vars ()
  297.  
  298.  
  299. def grok_environment_error (exc, prefix="error: "):
  300.     """Generate a useful error message from an EnvironmentError (IOError or
  301.     OSError) exception object.  Handles Python 1.5.1 and 1.5.2 styles, and
  302.     does what it can to deal with exception objects that don't have a
  303.     filename (which happens when the error is due to a two-file operation,
  304.     such as 'rename()' or 'link()'.  Returns the error message as a string
  305.     prefixed with 'prefix'.
  306.     """
  307.     # check for Python 1.5.2-style {IO,OS}Error exception objects
  308.     if hasattr(exc, 'filename') and hasattr(exc, 'strerror'):
  309.         if exc.filename:
  310.             error = prefix + "%s: %s" % (exc.filename, exc.strerror)
  311.         else:
  312.             # two-argument functions in posix module don't
  313.             # include the filename in the exception object!
  314.             error = prefix + "%s" % exc.strerror
  315.     else:
  316.         error = prefix + str(exc[-1])
  317.  
  318.     return error
  319.  
  320.  
  321. # Needed by 'split_quoted()'
  322. _wordchars_re = _squote_re = _dquote_re = None
  323. def _init_regex():
  324.     global _wordchars_re, _squote_re, _dquote_re
  325.     _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
  326.     _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
  327.     _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
  328.  
  329. def split_quoted (s):
  330.     """Split a string up according to Unix shell-like rules for quotes and
  331.     backslashes.  In short: words are delimited by spaces, as long as those
  332.     spaces are not escaped by a backslash, or inside a quoted string.
  333.     Single and double quotes are equivalent, and the quote characters can
  334.     be backslash-escaped.  The backslash is stripped from any two-character
  335.     escape sequence, leaving only the escaped character.  The quote
  336.     characters are stripped from any quoted string.  Returns a list of
  337.     words.
  338.     """
  339.  
  340.     # This is a nice algorithm for splitting up a single string, since it
  341.     # doesn't require character-by-character examination.  It was a little
  342.     # bit of a brain-bender to get it working right, though...
  343.     if _wordchars_re is None: _init_regex()
  344.  
  345.     s = string.strip(s)
  346.     words = []
  347.     pos = 0
  348.  
  349.     while s:
  350.         m = _wordchars_re.match(s, pos)
  351.         end = m.end()
  352.         if end == len(s):
  353.             words.append(s[:end])
  354.             break
  355.  
  356.         if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
  357.             words.append(s[:end])       # we definitely have a word delimiter
  358.             s = string.lstrip(s[end:])
  359.             pos = 0
  360.  
  361.         elif s[end] == '\\':            # preserve whatever is being escaped;
  362.                                         # will become part of the current word
  363.             s = s[:end] + s[end+1:]
  364.             pos = end+1
  365.  
  366.         else:
  367.             if s[end] == "'":           # slurp singly-quoted string
  368.                 m = _squote_re.match(s, end)
  369.             elif s[end] == '"':         # slurp doubly-quoted string
  370.                 m = _dquote_re.match(s, end)
  371.             else:
  372.                 raise RuntimeError, \
  373.                       "this can't happen (bad char '%c')" % s[end]
  374.  
  375.             if m is None:
  376.                 raise ValueError, \
  377.                       "bad string (mismatched %s quotes?)" % s[end]
  378.  
  379.             (beg, end) = m.span()
  380.             s = s[:beg] + s[beg+1:end-1] + s[end:]
  381.             pos = m.end() - 2
  382.  
  383.         if pos >= len(s):
  384.             words.append(s)
  385.             break
  386.  
  387.     return words
  388.  
  389. # split_quoted ()
  390.  
  391.  
  392. def execute (func, args, msg=None, verbose=0, dry_run=0):
  393.     """Perform some action that affects the outside world (eg.  by
  394.     writing to the filesystem).  Such actions are special because they
  395.     are disabled by the 'dry_run' flag.  This method takes care of all
  396.     that bureaucracy for you; all you have to do is supply the
  397.     function to call and an argument tuple for it (to embody the
  398.     "external action" being performed), and an optional message to
  399.     print.
  400.     """
  401.     if msg is None:
  402.         msg = "%s%r" % (func.__name__, args)
  403.         if msg[-2:] == ',)':        # correct for singleton tuple
  404.             msg = msg[0:-2] + ')'
  405.  
  406.     log.info(msg)
  407.     if not dry_run:
  408.         func(*args)
  409.  
  410.  
  411. def strtobool (val):
  412.     """Convert a string representation of truth to true (1) or false (0).
  413.  
  414.     True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
  415.     are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
  416.     'val' is anything else.
  417.     """
  418.     val = string.lower(val)
  419.     if val in ('y', 'yes', 't', 'true', 'on', '1'):
  420.         return 1
  421.     elif val in ('n', 'no', 'f', 'false', 'off', '0'):
  422.         return 0
  423.     else:
  424.         raise ValueError, "invalid truth value %r" % (val,)
  425.  
  426.  
  427. def byte_compile (py_files,
  428.                   optimize=0, force=0,
  429.                   prefix=None, base_dir=None,
  430.                   verbose=1, dry_run=0,
  431.                   direct=None):
  432.     """Byte-compile a collection of Python source files to either .pyc
  433.     or .pyo files in the same directory.  'py_files' is a list of files
  434.     to compile; any files that don't end in ".py" are silently skipped.
  435.     'optimize' must be one of the following:
  436.       0 - don't optimize (generate .pyc)
  437.       1 - normal optimization (like "python -O")
  438.       2 - extra optimization (like "python -OO")
  439.     If 'force' is true, all files are recompiled regardless of
  440.     timestamps.
  441.  
  442.     The source filename encoded in each bytecode file defaults to the
  443.     filenames listed in 'py_files'; you can modify these with 'prefix' and
  444.     'basedir'.  'prefix' is a string that will be stripped off of each
  445.     source filename, and 'base_dir' is a directory name that will be
  446.     prepended (after 'prefix' is stripped).  You can supply either or both
  447.     (or neither) of 'prefix' and 'base_dir', as you wish.
  448.  
  449.     If 'dry_run' is true, doesn't actually do anything that would
  450.     affect the filesystem.
  451.  
  452.     Byte-compilation is either done directly in this interpreter process
  453.     with the standard py_compile module, or indirectly by writing a
  454.     temporary script and executing it.  Normally, you should let
  455.     'byte_compile()' figure out to use direct compilation or not (see
  456.     the source for details).  The 'direct' flag is used by the script
  457.     generated in indirect mode; unless you know what you're doing, leave
  458.     it set to None.
  459.     """
  460.     # nothing is done if sys.dont_write_bytecode is True
  461.     if sys.dont_write_bytecode:
  462.         raise DistutilsByteCompileError('byte-compiling is disabled.')
  463.  
  464.     # First, if the caller didn't force us into direct or indirect mode,
  465.     # figure out which mode we should be in.  We take a conservative
  466.     # approach: choose direct mode *only* if the current interpreter is
  467.     # in debug mode and optimize is 0.  If we're not in debug mode (-O
  468.     # or -OO), we don't know which level of optimization this
  469.     # interpreter is running with, so we can't do direct
  470.     # byte-compilation and be certain that it's the right thing.  Thus,
  471.     # always compile indirectly if the current interpreter is in either
  472.     # optimize mode, or if either optimization level was requested by
  473.     # the caller.
  474.     if direct is None:
  475.         direct = (__debug__ and optimize == 0)
  476.  
  477.     # "Indirect" byte-compilation: write a temporary script and then
  478.     # run it with the appropriate flags.
  479.     if not direct:
  480.         try:
  481.             from tempfile import mkstemp
  482.             (script_fd, script_name) = mkstemp(".py")
  483.         except ImportError:
  484.             from tempfile import mktemp
  485.             (script_fd, script_name) = None, mktemp(".py")
  486.         log.info("writing byte-compilation script '%s'", script_name)
  487.         if not dry_run:
  488.             if script_fd is not None:
  489.                 script = os.fdopen(script_fd, "w")
  490.             else:
  491.                 script = open(script_name, "w")
  492.  
  493.             script.write("""\
  494. from distutils.util import byte_compile
  495. files = [
  496. """)
  497.  
  498.             # XXX would be nice to write absolute filenames, just for
  499.             # safety's sake (script should be more robust in the face of
  500.             # chdir'ing before running it).  But this requires abspath'ing
  501.             # 'prefix' as well, and that breaks the hack in build_lib's
  502.             # 'byte_compile()' method that carefully tacks on a trailing
  503.             # slash (os.sep really) to make sure the prefix here is "just
  504.             # right".  This whole prefix business is rather delicate -- the
  505.             # problem is that it's really a directory, but I'm treating it
  506.             # as a dumb string, so trailing slashes and so forth matter.
  507.  
  508.             #py_files = map(os.path.abspath, py_files)
  509.             #if prefix:
  510.             #    prefix = os.path.abspath(prefix)
  511.  
  512.             script.write(string.join(map(repr, py_files), ",\n") + "]\n")
  513.             script.write("""
  514. byte_compile(files, optimize=%r, force=%r,
  515.              prefix=%r, base_dir=%r,
  516.              verbose=%r, dry_run=0,
  517.              direct=1)
  518. """ % (optimize, force, prefix, base_dir, verbose))
  519.  
  520.             script.close()
  521.  
  522.         cmd = [sys.executable, script_name]
  523.         if optimize == 1:
  524.             cmd.insert(1, "-O")
  525.         elif optimize == 2:
  526.             cmd.insert(1, "-OO")
  527.         spawn(cmd, dry_run=dry_run)
  528.         execute(os.remove, (script_name,), "removing %s" % script_name,
  529.                 dry_run=dry_run)
  530.  
  531.     # "Direct" byte-compilation: use the py_compile module to compile
  532.     # right here, right now.  Note that the script generated in indirect
  533.     # mode simply calls 'byte_compile()' in direct mode, a weird sort of
  534.     # cross-process recursion.  Hey, it works!
  535.     else:
  536.         from py_compile import compile
  537.  
  538.         for file in py_files:
  539.             if file[-3:] != ".py":
  540.                 # This lets us be lazy and not filter filenames in
  541.                 # the "install_lib" command.
  542.                 continue
  543.  
  544.             # Terminology from the py_compile module:
  545.             #   cfile - byte-compiled file
  546.             #   dfile - purported source filename (same as 'file' by default)
  547.             cfile = file + (__debug__ and "c" or "o")
  548.             dfile = file
  549.             if prefix:
  550.                 if file[:len(prefix)] != prefix:
  551.                     raise ValueError, \
  552.                           ("invalid prefix: filename %r doesn't start with %r"
  553.                            % (file, prefix))
  554.                 dfile = dfile[len(prefix):]
  555.             if base_dir:
  556.                 dfile = os.path.join(base_dir, dfile)
  557.  
  558.             cfile_base = os.path.basename(cfile)
  559.             if direct:
  560.                 if force or newer(file, cfile):
  561.                     log.info("byte-compiling %s to %s", file, cfile_base)
  562.                     if not dry_run:
  563.                         compile(file, cfile, dfile)
  564.                 else:
  565.                     log.debug("skipping byte-compilation of %s to %s",
  566.                               file, cfile_base)
  567.  
  568. # byte_compile ()
  569.  
  570. def rfc822_escape (header):
  571.     """Return a version of the string escaped for inclusion in an
  572.     RFC-822 header, by ensuring there are 8 spaces space after each newline.
  573.     """
  574.     lines = string.split(header, '\n')
  575.     header = string.join(lines, '\n' + 8*' ')
  576.     return header
  577.